// 一些工具类方法
import api from './api';

let ERR_CODE = {
    SUCCESS: '0', //成功
    RE_LOGIN: '00100', //需要登录
    BIND_PHONE: '00128', //绑定手机
};
let ERR_CODE_MINI = {
    SUCCESS: '0001', //成功
    NEED_SHOW_DIALOG: '120001', //需要弹窗
    NOT_SHOW_DIALOG: '120002', //不需要弹窗
    RE_LOGIN: '1001', //需要登录
    BIND_PHONE: '1012', //绑定手机
    ERROR: '0002', //异常
    REQUEST_ERROR: '0003', //请求参数不合法
    GOODS_NUM_ERROR: '6001' //商品数量错误
}


let header = {
    "content-type": "application/x-www-form-urlencoded",
    "client-channel": "weixin-miniprogram"
}

//  url: 接口的路径，如果是大当家域名下的，只需写的是域名后的那部分；如果是别的域名的，刚写完整的接口路径
// method: 请求的方法，默认是POST
// headerOps: 请求头要额外加的，不需要就不传
// success: 请求成功返回的回调
// fail: 请求失败返回的回调

function http({
    url,
    method = 'POST',
    headerOps = {},
    data = {},
    success,
    fail
}) {
    url = url && url.toString();
    //  检查网络状态
    httpUtil.getNetworkType(url, ({ url }) => {
        //  获取token
        let token = wx.getStorageSync('token');
        httpUtil.createHeader(url, headerOps, ({ url, headerOps, type }) => {
            token ? type === 'normal' ? header.token = token : header.loginToken = token : '';
            let options = {
                url,
                data,
                header,
                method,
                success: res => {
                    //  过滤状态码
                    httpUtil.filterStatus(res, type, result => {
                        // 过滤后返回data对象
                        success && typeof success === 'function' && success(result)
                    }, err => {
                        // 业务异常返回错误对象
                        fail && typeof fail === 'function' && fail(err, res)
                    }, {
                        url,
                        header,
                        data,
                        method,
                        success,
                        fail
                    })
                }
            }
            wx.request(options)
        })
    })

}


const httpUtil = {
    //  获取网络状态
    getNetworkType(url, callBack) {
        try {
            wx.getNetworkType({
                success: (result) => {
                    if (result && result.networkType) {
                        if (result.networkType && result.networkType != 'none') {
                            callBack && typeof callBack === 'function' && callBack({
                                url
                            })
                        } else { //无网络
                            // 提示网络不可用
                            //  requestTask && typeof requestTask === 'object' && typeof requestTask.abort === 'function' && requestTask.abort();
                            if (!getApp().isShowModal) {
                                //  防止显示多个
                                getApp().isShowModal = true;
                                wx.showModal({
                                    content: '网络错误，请稍后重试',
                                    confirmText: '刷新重试',
                                    success: res => {
                                        //  初始化显示标识
                                        getApp().isShowModal = false;
                                        if (res.confirm) {
                                            let pages = getCurrentPages();
                                            let current = pages[pages.length - 1];
                                            let options = '';
                                            // 拼接当前页面的参数
                                            if (current.options && Object.keys(current.options).length > 0) {
                                                for (let i in current.options) {
                                                    let item = i + '=' + current.options[i] + '&';
                                                    options += item;
                                                }
                                            }
                                            let pageUrl = options ? '/' + current.route + '?' + options : '/' + current.route;
                                            let naviMethod = httpUtil.isTabUrl(current.route) ? 'reLaunch' : 'redirectTo'; //如果是tab页则用reLaunch, 其他页面用redirectTo
                                            wx[naviMethod]({
                                                url: pageUrl,
                                            })
                                        } else {

                                        }
                                    }
                                })
                            }
                        }
                    } else {
                        //  如果方法报错，会默认是网络正常
                        callBack && typeof callBack === 'function' && callBack({
                            url
                        })
                    }
                },
                fail: () => {
                    //  如果方法报错，会默认是网络正常
                    callBack && typeof callBack === 'function' && callBack({
                        url
                    })
                }
            })
        } catch (e) {
            //  如果方法报错，会默认是网络正常
            callBack && typeof callBack === 'function' && callBack({
                url
            })
        }
    },

    // 请求头拼接
    createHeader(url, options, callback) {
        let type = 'normal';
        //  如果是小程序后台的接口
        if (url.indexOf('miniapp/v1') > -1) {
            type = 'oldUrl'
        }
        // 自定义headers参数
        if (typeof options === 'object' && Object.keys(options).length) {
            header = Object.assigin({}, header, options)
        }
        url = httpUtil.concatUrl(url)
        callback && typeof callback === 'function' && callback({
            url,
            header,
            type
        })
    },

    // 请求地址拼接
    concatUrl(url, type) {
        if (url && typeof url === 'string') {
            // 本域名的
            if (url.indexOf('https://') === -1) {
                url = api.baseUrl + url
            }
        }
        return url
    },

    //  处理接口返回的数据
    filterStatus(res, type, callback, fail, reLoadData) {
        let {
            statusCode,
            data
        } = res && typeof (res) == 'object' ? res : {};
        //  请求成功
        if (statusCode == 200) {
            let errCode = data ? type == 'normal' ? data.ret.code : data.errCode : '';
            let errMsg = data ? type == 'normal' ? data.ret.message : data.message : '';
            //  请求成功--会返回正个data, 里面包括errorCode
            if (errCode == ERR_CODE.SUCCESS || errCode == ERR_CODE_MINI.SUCCESS || errCode == ERR_CODE_MINI.NEED_SHOW_DIALOG || errCode == ERR_CODE_MINI.NOT_SHOW_DIALOG) {
                callback && typeof callback === 'function' && callback(data)
            } else if (errCode == ERR_CODE.RE_LOGIN || errCode == ERR_CODE_MINI.RE_LOGIN) { //重新登录
                httpUtil.login(reLoadData, (reLoadData) => {
                    http(reLoadData)
                })
            } else if (errCode == ERR_CODE.BIND_PHONE || errCode == ERR_CODE_MINI.BIND_PHONE) { //去绑定手机号
                fail && typeof fail === 'function' && fail(errMsg);
                if (url != '/coupon/exchangeCoupon') {
                    wx.redirectTo({
                        url: '/pages/subPackages/user/bindPhone/bindPhone'
                    });
                } else {
                    return;
                }
            } else { //请求错误
                fail && typeof fail === 'function' && fail(errMsg ? errMsg : '请求错误，请重试');
            }
        } else if (statusCode == 429) { //服务器限流
            wx.redirectTo({
                url: '/pages/limit/limit'
            })
        } else if (statusCode == 504) {
            wx.redirectTo({
                url: '/pages/overTime/overTime'
            })
        } else {
            fail && typeof fail === 'function' && fail('请求错误，请重试');
        }
    },

    login(reLoadData, suc) {
        wx.login({
            success: res => {
                let jsCode = res.code;

            }
        })
    },

    // 公共的跳转方式, 传的data中 url(跳转的页面路径)是必须的，主要是有跳转到收藏有礼、小程序内部跳转、跳转网页；(跳转去别的小程序有待兼容); 由于首页banner的是以mark来区分是否跳收藏有礼，而广告模块是以linkType来区分的，所以在跳转时统一处理成linkType,后续需要改的时候才改；linkType: ALI_MINI_COLLECT_POLITE(收藏有礼)、 CUSTOM_LINK(自定义链接)。
    skipPageHandle(data = {}) {
        let param = data;
        // 跳转收藏有礼
        if (param.linkType == 'H5_LINK') {
            httpUtil.isHttpUrl(param)
        } else {
            httpUtil.skipType(param);
        }
    },

    isHttpUrl(param) {
        if (param.url.indexOf('https') > -1) {
            let urlArray = param.url.split('?');
            urlArray[1] = urlArray[1] ? urlArray[1].replace(/[=]/g, '!') : ''
            wx.navigateTo({
                url: '/pages/subPackages/user/webView/webView?mainUrl=' + urlArray[0] + '&para=' + urlArray[1], //路径必须跟app.json一致
            })
        } else {
            httpUtil.skipType(param);
        }
    },

    skipType(param) {
        // 要判断简单判断是否是h5链接
        if (param.url.substring(0, 4).indexOf('http') > -1) {
            //  my.call('startApp', {
            //    appId: '20000067',
            //    param: {
            //      url: param.url,
            //      chInfo: `ch_${api.DDJAppId}`
            //    }
            //  })
        } else {
            // 判断是否是几个tab页，tab页要用switchTab方法跳转，不然会当普通页面跳转
            // 是tab页要用switchTab
            if (httpUtil.isTabUrl(param.url)) {
                wx.switchTab({
                    url: param.url
                });
            } else {
                // 是否跳转方法是重定向的，默认是navigateTo
                let method = param.method && param.method != "null" && param.method != "undefined" ? param.method : 'navigateTo'
                wx[method]({
                    url: param.url
                })
            }
        }
    },

    // 判断是否是tab页路径
    isTabUrl(url = '') {
        if (url.indexOf('pages/home/home') > -1 || url.indexOf('pages/category/category') > -1 || url.indexOf('pages/cart/cart') > -1 || url.indexOf('pages/user/user') > -1) {
            return true;
        } else {
            return false;
        }
    },
}

module.exports = {
    api,
    http,
    httpUtil,
};